package cn.jasonone.jame.model;

import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.beans.property.IntegerProperty;
import javafx.beans.property.SimpleIntegerProperty;
import javafx.collections.FXCollections;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.image.Image;
import javafx.scene.image.ImageView;
import javafx.scene.paint.Color;
import javafx.util.Duration;
import lombok.extern.slf4j.Slf4j;

import java.util.List;


/**
 * 动画类
 */
@Slf4j
public class Animation extends Rect {
    /**
     * 动画时间轴
     */
    private Timeline timeline;
    /**
     * 图片关键帧
     */
    private Image[] images;
    /**
     * 颜色关键帧
     */
    private List<Color> colors;
    /**
     * 当前图片索引
     */
    private IntegerProperty index = new SimpleIntegerProperty();
    /**
     * 是否是最后一张
     */
    private boolean last;

    /**
     * 创建循环播放动画
     *
     * @param duration 每帧的间隔时间
     * @param autoPlay 是否自动播放
     * @param images   图片列表
     */
    public Animation(Duration duration, boolean autoPlay, Image... images) {
        this(Timeline.INDEFINITE, autoPlay, duration, (index, maxIndex, e) -> index == maxIndex ? 0 : index + 1, images, null);
    }

    /**
     * 创建循环播放动画
     *
     * @param duration 每帧的间隔时间
     * @param autoPlay 是否自动播放
     * @param colors   颜色列表
     */
    public Animation(Duration duration, boolean autoPlay, Color... colors) {
        this(Timeline.INDEFINITE, autoPlay, duration, (index, maxIndex, e) -> index == maxIndex ? 0 : index + 1, null, colors);
    }

    /**
     * 创建循环播放动画
     *
     * @param cycle    播放次数
     * @param duration 每帧的间隔时间
     * @param autoPlay 是否自动播放
     * @param images   图片列表
     */
    public Animation(int cycle, Duration duration, boolean autoPlay, Image... images) {
        this(cycle, autoPlay, duration, (index, maxIndex, e) -> index == maxIndex ? 0 : index + 1, images, null);
    }

    /**
     * 创建循环播放动画
     *
     * @param cycle    播放次数
     * @param duration 每帧的间隔时间
     * @param autoPlay 是否自动播放
     * @param colors   颜色列表
     */
    public Animation(int cycle, Duration duration, boolean autoPlay, Color... colors) {
        this(cycle, autoPlay, duration, (index, maxIndex, e) -> index == maxIndex ? 0 : index + 1, null, colors);
    }

    /**
     * 创建循环播放动画
     *
     * @param duration 每帧的间隔时间
     * @param autoPlay 是否自动播放
     * @param keyFrame 关键帧事件
     * @param images   图片列表
     */
    public Animation(Duration duration, boolean autoPlay, AnimationKeyFrame keyFrame, Image... images) {
        this(Timeline.INDEFINITE, autoPlay, duration, keyFrame, images, null);
    }

    /**
     * 创建循环播放动画
     *
     * @param duration 每帧的间隔时间
     * @param autoPlay 是否自动播放
     * @param keyFrame 关键帧事件
     * @param colors   颜色列表
     */
    public Animation(Duration duration, boolean autoPlay, AnimationKeyFrame keyFrame, Color... colors) {
        this(Timeline.INDEFINITE, autoPlay, duration, keyFrame, null, colors);
    }

    /**
     * 创建自动循环播放动画
     *
     * @param duration 每帧的间隔时间
     * @param images   图片列表
     */
    public Animation(Duration duration, Image... images) {
        this(Timeline.INDEFINITE, true, duration, (index, maxIndex, e) -> index == maxIndex ? 0 : index + 1, images, null);
    }

    /**
     * 创建自动循环播放动画
     *
     * @param duration 每帧的间隔时间
     * @param colors   颜色列表
     */
    public Animation(Duration duration, Color... colors) {
        this(Timeline.INDEFINITE, true, duration, (index, maxIndex, e) -> index == maxIndex ? 0 : index + 1, null, colors);
    }

    /**
     * 创建自动循环播放动画
     *
     * @param duration 每帧的间隔时间
     * @param keyFrame 关键帧事件
     * @param images   图片列表
     */
    public Animation(Duration duration, AnimationKeyFrame keyFrame, Image... images) {
        this(Timeline.INDEFINITE, true, duration, keyFrame, images, null);
    }

    /**
     * 创建自动循环播放动画
     *
     * @param duration 每帧的间隔时间
     * @param keyFrame 关键帧事件
     * @param colors   颜色列表
     */
    public Animation(Duration duration, AnimationKeyFrame keyFrame, Color... colors) {
        this(Timeline.INDEFINITE, true, duration, keyFrame, null, colors);
    }

    /**
     * 创建自动播放动画
     *
     * @param cycle    播放次数
     * @param duration 每帧的间隔时间
     * @param keyFrame 关键帧事件
     * @param images   图片列表
     */
    public Animation(int cycle, Duration duration, AnimationKeyFrame keyFrame, Image... images) {
        this(cycle, true, duration, keyFrame, images, null);
    }

    /**
     * 创建自动播放动画
     *
     * @param cycle    播放次数
     * @param duration 每帧的间隔时间
     * @param keyFrame 关键帧事件
     * @param colors   颜色列表
     */
    public Animation(int cycle, Duration duration, AnimationKeyFrame keyFrame, Color... colors) {
        this(cycle, true, duration, keyFrame, null, colors);
    }

    /**
     * 创建动画
     *
     * @param cycle    播放次数
     * @param autoPlay 是否自动播放
     * @param duration 每帧的间隔时间
     * @param keyFrame 关键帧事件
     * @param images   图片列表
     */
    public Animation(int cycle, boolean autoPlay, Duration duration, AnimationKeyFrame keyFrame, Image[] images, Color[] colors) {
        this.images = images == null ? new Image[0] : images;
        this.colors = colors == null ? FXCollections.observableArrayList(Color.WHITE) : FXCollections.observableArrayList(colors);
        if (this.images.length > 0) {
            this.setSize(this.images[0].getWidth(), this.images[0].getHeight());
        }
        if (this.images.length > 1 || this.colors.size() > 1) {
            //有多张图片时才创建时间轴
            timeline = new Timeline();
            //播放次数
            timeline.setCycleCount(cycle);
            //创建关键帧
            KeyFrame frame = new KeyFrame(duration, new EventHandler<ActionEvent>() {
                @Override
                public void handle(ActionEvent event) {
                    int i = keyFrame.handler(index.get(), images.length - 1, event);
                    if (images.length > 0) {
                        if (i < images.length) {
                            index.set(i);
                            setSize(images[i].getWidth(), images[i].getHeight());
                        }
                    } else if (colors.length > 0) {
                        if (i < colors.length) {
                            index.set(i);
                        }
                    }
                }
            });
            //将关键帧添加到时间轴上
            timeline.getKeyFrames().add(frame);
            if (autoPlay) {
                this.play();
            }
        }
    }


    /**
     * 启动动画
     */
    public void play() {
        if (timeline != null) {
            timeline.play();
        }
    }

    /**
     * 暂停动画
     */
    public void pause() {
        if (timeline != null) {
            timeline.pause();
        }
    }

    /**
     * 停止动画
     */
    public void stop() {
        if (timeline != null) {
            timeline.stop();
        }
    }

    /**
     * 获得当前显示的图片
     *
     * @return 图片对象
     */
    public Image getImage() {
        if (this.images == null || this.images.length == 0) {
            return null;
        }
        if (this.images != null) {
            this.last=this.index.get() == this.images.length-1;
        }else if(this.colors != null){
            this.last=this.index.get()==this.colors.size()-1;
        }
        return this.images[index.get()];
    }

    /**
     * 获得当前显示的颜色
     *
     * @return 颜色对象
     */
    public Color getColor() {
        if (this.images != null) {
            this.last=this.index.get() == this.images.length-1;
        }else if(this.colors != null){
            this.last=this.index.get()==this.colors.size()-1;
        }
        if (this.colors.size() > index.get()) {
            return this.colors.get(index.get());
        }
        return this.colors.get(0);
    }


    public void setColor(Color... colors) {
        this.colors.clear();
        this.colors = FXCollections.observableArrayList(colors);
    }

    public int getIndex() {

        return this.index.get();
    }

    public boolean isLast(){
        return this.last;
    }
}
